home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / asm-generic / vmlinux.lds.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  12.9 KB  |  413 lines
  1. #ifndef LOAD_OFFSET
  2. #define LOAD_OFFSET 0
  3. #endif
  4.  
  5. #ifndef VMLINUX_SYMBOL
  6. #define VMLINUX_SYMBOL(_sym_) _sym_
  7. #endif
  8.  
  9. /* Align . to a 8 byte boundary equals to maximum function alignment. */
  10. #define ALIGN_FUNCTION()  . = ALIGN(8)
  11.  
  12. /* The actual configuration determine if the init/exit sections
  13.  * are handled as text/data or they can be discarded (which
  14.  * often happens at runtime)
  15.  */
  16. #ifdef CONFIG_HOTPLUG
  17. #define DEV_KEEP(sec)    *(.dev##sec)
  18. #define DEV_DISCARD(sec)
  19. #else
  20. #define DEV_KEEP(sec)
  21. #define DEV_DISCARD(sec) *(.dev##sec)
  22. #endif
  23.  
  24. #ifdef CONFIG_HOTPLUG_CPU
  25. #define CPU_KEEP(sec)    *(.cpu##sec)
  26. #define CPU_DISCARD(sec)
  27. #else
  28. #define CPU_KEEP(sec)
  29. #define CPU_DISCARD(sec) *(.cpu##sec)
  30. #endif
  31.  
  32. #if defined(CONFIG_MEMORY_HOTPLUG)
  33. #define MEM_KEEP(sec)    *(.mem##sec)
  34. #define MEM_DISCARD(sec)
  35. #else
  36. #define MEM_KEEP(sec)
  37. #define MEM_DISCARD(sec) *(.mem##sec)
  38. #endif
  39.  
  40. #ifdef CONFIG_FTRACE_MCOUNT_RECORD
  41. #define MCOUNT_REC()    VMLINUX_SYMBOL(__start_mcount_loc) = .; \
  42.             *(__mcount_loc)                \
  43.             VMLINUX_SYMBOL(__stop_mcount_loc) = .;
  44. #else
  45. #define MCOUNT_REC()
  46. #endif
  47.  
  48. /* .data section */
  49. #define DATA_DATA                            \
  50.     *(.data)                            \
  51.     *(.data.init.refok)                        \
  52.     *(.ref.data)                            \
  53.     DEV_KEEP(init.data)                        \
  54.     DEV_KEEP(exit.data)                        \
  55.     CPU_KEEP(init.data)                        \
  56.     CPU_KEEP(exit.data)                        \
  57.     MEM_KEEP(init.data)                        \
  58.     MEM_KEEP(exit.data)                        \
  59.     . = ALIGN(8);                            \
  60.     VMLINUX_SYMBOL(__start___markers) = .;                \
  61.     *(__markers)                            \
  62.     VMLINUX_SYMBOL(__stop___markers) = .;                \
  63.     VMLINUX_SYMBOL(__start___tracepoints) = .;            \
  64.     *(__tracepoints)                        \
  65.     VMLINUX_SYMBOL(__stop___tracepoints) = .;
  66.  
  67. #define RO_DATA(align)                            \
  68.     . = ALIGN((align));                        \
  69.     .rodata           : AT(ADDR(.rodata) - LOAD_OFFSET) {        \
  70.         VMLINUX_SYMBOL(__start_rodata) = .;            \
  71.         *(.rodata) *(.rodata.*)                    \
  72.         *(__vermagic)        /* Kernel version magic */    \
  73.         *(__markers_strings)    /* Markers: strings */        \
  74.         *(__tracepoints_strings)/* Tracepoints: strings */    \
  75.     }                                \
  76.                                     \
  77.     .rodata1          : AT(ADDR(.rodata1) - LOAD_OFFSET) {        \
  78.         *(.rodata1)                        \
  79.     }                                \
  80.                                     \
  81.     BUG_TABLE                            \
  82.                                     \
  83.     /* PCI quirks */                        \
  84.     .pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {    \
  85.         VMLINUX_SYMBOL(__start_pci_fixups_early) = .;        \
  86.         *(.pci_fixup_early)                    \
  87.         VMLINUX_SYMBOL(__end_pci_fixups_early) = .;        \
  88.         VMLINUX_SYMBOL(__start_pci_fixups_header) = .;        \
  89.         *(.pci_fixup_header)                    \
  90.         VMLINUX_SYMBOL(__end_pci_fixups_header) = .;        \
  91.         VMLINUX_SYMBOL(__start_pci_fixups_final) = .;        \
  92.         *(.pci_fixup_final)                    \
  93.         VMLINUX_SYMBOL(__end_pci_fixups_final) = .;        \
  94.         VMLINUX_SYMBOL(__start_pci_fixups_enable) = .;        \
  95.         *(.pci_fixup_enable)                    \
  96.         VMLINUX_SYMBOL(__end_pci_fixups_enable) = .;        \
  97.         VMLINUX_SYMBOL(__start_pci_fixups_resume) = .;        \
  98.         *(.pci_fixup_resume)                    \
  99.         VMLINUX_SYMBOL(__end_pci_fixups_resume) = .;        \
  100.         VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .;    \
  101.         *(.pci_fixup_resume_early)                \
  102.         VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .;    \
  103.         VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .;        \
  104.         *(.pci_fixup_suspend)                    \
  105.         VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .;        \
  106.     }                                \
  107.                                     \
  108.     /* Built-in firmware blobs */                    \
  109.     .builtin_fw        : AT(ADDR(.builtin_fw) - LOAD_OFFSET) {    \
  110.         VMLINUX_SYMBOL(__start_builtin_fw) = .;            \
  111.         *(.builtin_fw)                        \
  112.         VMLINUX_SYMBOL(__end_builtin_fw) = .;            \
  113.     }                                \
  114.                                     \
  115.     /* RapidIO route ops */                        \
  116.     .rio_route        : AT(ADDR(.rio_route) - LOAD_OFFSET) {    \
  117.         VMLINUX_SYMBOL(__start_rio_route_ops) = .;        \
  118.         *(.rio_route_ops)                    \
  119.         VMLINUX_SYMBOL(__end_rio_route_ops) = .;        \
  120.     }                                \
  121.                                     \
  122.     TRACEDATA                            \
  123.                                     \
  124.     /* Kernel symbol table: Normal symbols */            \
  125.     __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {        \
  126.         VMLINUX_SYMBOL(__start___ksymtab) = .;            \
  127.         *(__ksymtab)                        \
  128.         VMLINUX_SYMBOL(__stop___ksymtab) = .;            \
  129.     }                                \
  130.                                     \
  131.     /* Kernel symbol table: GPL-only symbols */            \
  132.     __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {    \
  133.         VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;        \
  134.         *(__ksymtab_gpl)                    \
  135.         VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;        \
  136.     }                                \
  137.                                     \
  138.     /* Kernel symbol table: Normal unused symbols */        \
  139.     __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {    \
  140.         VMLINUX_SYMBOL(__start___ksymtab_unused) = .;        \
  141.         *(__ksymtab_unused)                    \
  142.         VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;        \
  143.     }                                \
  144.                                     \
  145.     /* Kernel symbol table: GPL-only unused symbols */        \
  146.     __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
  147.         VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;    \
  148.         *(__ksymtab_unused_gpl)                    \
  149.         VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;    \
  150.     }                                \
  151.                                     \
  152.     /* Kernel symbol table: GPL-future-only symbols */        \
  153.     __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
  154.         VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;    \
  155.         *(__ksymtab_gpl_future)                    \
  156.         VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;    \
  157.     }                                \
  158.                                     \
  159.     /* Kernel symbol table: Normal symbols */            \
  160.     __kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {        \
  161.         VMLINUX_SYMBOL(__start___kcrctab) = .;            \
  162.         *(__kcrctab)                        \
  163.         VMLINUX_SYMBOL(__stop___kcrctab) = .;            \
  164.     }                                \
  165.                                     \
  166.     /* Kernel symbol table: GPL-only symbols */            \
  167.     __kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {    \
  168.         VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;        \
  169.         *(__kcrctab_gpl)                    \
  170.         VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;        \
  171.     }                                \
  172.                                     \
  173.     /* Kernel symbol table: Normal unused symbols */        \
  174.     __kcrctab_unused  : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) {    \
  175.         VMLINUX_SYMBOL(__start___kcrctab_unused) = .;        \
  176.         *(__kcrctab_unused)                    \
  177.         VMLINUX_SYMBOL(__stop___kcrctab_unused) = .;        \
  178.     }                                \
  179.                                     \
  180.     /* Kernel symbol table: GPL-only unused symbols */        \
  181.     __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
  182.         VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;    \
  183.         *(__kcrctab_unused_gpl)                    \
  184.         VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;    \
  185.     }                                \
  186.                                     \
  187.     /* Kernel symbol table: GPL-future-only symbols */        \
  188.     __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
  189.         VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;    \
  190.         *(__kcrctab_gpl_future)                    \
  191.         VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .;    \
  192.     }                                \
  193.                                     \
  194.     /* Kernel symbol table: strings */                \
  195.         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {    \
  196.         *(__ksymtab_strings)                    \
  197.     }                                \
  198.                                     \
  199.     /* __*init sections */                        \
  200.     __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) {        \
  201.         *(.ref.rodata)                        \
  202.         MCOUNT_REC()                        \
  203.         DEV_KEEP(init.rodata)                    \
  204.         DEV_KEEP(exit.rodata)                    \
  205.         CPU_KEEP(init.rodata)                    \
  206.         CPU_KEEP(exit.rodata)                    \
  207.         MEM_KEEP(init.rodata)                    \
  208.         MEM_KEEP(exit.rodata)                    \
  209.     }                                \
  210.                                     \
  211.     /* Built-in module parameters. */                \
  212.     __param : AT(ADDR(__param) - LOAD_OFFSET) {            \
  213.         VMLINUX_SYMBOL(__start___param) = .;            \
  214.         *(__param)                        \
  215.         VMLINUX_SYMBOL(__stop___param) = .;            \
  216.         . = ALIGN((align));                    \
  217.         VMLINUX_SYMBOL(__end_rodata) = .;            \
  218.     }                                \
  219.     . = ALIGN((align));
  220.  
  221. /* RODATA provided for backward compatibility.
  222.  * All archs are supposed to use RO_DATA() */
  223. #define RODATA RO_DATA(4096)
  224.  
  225. #define SECURITY_INIT                            \
  226.     .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) { \
  227.         VMLINUX_SYMBOL(__security_initcall_start) = .;        \
  228.         *(.security_initcall.init)                 \
  229.         VMLINUX_SYMBOL(__security_initcall_end) = .;        \
  230.     }
  231.  
  232. /* .text section. Map to function alignment to avoid address changes
  233.  * during second ld run in second ld pass when generating System.map */
  234. #define TEXT_TEXT                            \
  235.         ALIGN_FUNCTION();                    \
  236.         *(.text.hot)                        \
  237.         *(.text)                        \
  238.         *(.ref.text)                        \
  239.         *(.text.init.refok)                    \
  240.         *(.exit.text.refok)                    \
  241.     DEV_KEEP(init.text)                        \
  242.     DEV_KEEP(exit.text)                        \
  243.     CPU_KEEP(init.text)                        \
  244.     CPU_KEEP(exit.text)                        \
  245.     MEM_KEEP(init.text)                        \
  246.     MEM_KEEP(exit.text)                        \
  247.         *(.text.unlikely)
  248.  
  249.  
  250. /* sched.text is aling to function alignment to secure we have same
  251.  * address even at second ld pass when generating System.map */
  252. #define SCHED_TEXT                            \
  253.         ALIGN_FUNCTION();                    \
  254.         VMLINUX_SYMBOL(__sched_text_start) = .;            \
  255.         *(.sched.text)                        \
  256.         VMLINUX_SYMBOL(__sched_text_end) = .;
  257.  
  258. /* spinlock.text is aling to function alignment to secure we have same
  259.  * address even at second ld pass when generating System.map */
  260. #define LOCK_TEXT                            \
  261.         ALIGN_FUNCTION();                    \
  262.         VMLINUX_SYMBOL(__lock_text_start) = .;            \
  263.         *(.spinlock.text)                    \
  264.         VMLINUX_SYMBOL(__lock_text_end) = .;
  265.  
  266. #define KPROBES_TEXT                            \
  267.         ALIGN_FUNCTION();                    \
  268.         VMLINUX_SYMBOL(__kprobes_text_start) = .;        \
  269.         *(.kprobes.text)                    \
  270.         VMLINUX_SYMBOL(__kprobes_text_end) = .;
  271.  
  272. /* Section used for early init (in .S files) */
  273. #define HEAD_TEXT  *(.head.text)
  274.  
  275. /* init and exit section handling */
  276. #define INIT_DATA                            \
  277.     *(.init.data)                            \
  278.     DEV_DISCARD(init.data)                        \
  279.     DEV_DISCARD(init.rodata)                    \
  280.     CPU_DISCARD(init.data)                        \
  281.     CPU_DISCARD(init.rodata)                    \
  282.     MEM_DISCARD(init.data)                        \
  283.     MEM_DISCARD(init.rodata)                    \
  284.     /* implement dynamic printk debug */                \
  285.     VMLINUX_SYMBOL(__start___verbose_strings) = .;                  \
  286.     *(__verbose_strings)                                            \
  287.     VMLINUX_SYMBOL(__stop___verbose_strings) = .;                   \
  288.     . = ALIGN(8);                            \
  289.     VMLINUX_SYMBOL(__start___verbose) = .;                          \
  290.     *(__verbose)                                                    \
  291.     VMLINUX_SYMBOL(__stop___verbose) = .;
  292.  
  293. #define INIT_TEXT                            \
  294.     *(.init.text)                            \
  295.     DEV_DISCARD(init.text)                        \
  296.     CPU_DISCARD(init.text)                        \
  297.     MEM_DISCARD(init.text)
  298.  
  299. #define EXIT_DATA                            \
  300.     *(.exit.data)                            \
  301.     DEV_DISCARD(exit.data)                        \
  302.     DEV_DISCARD(exit.rodata)                    \
  303.     CPU_DISCARD(exit.data)                        \
  304.     CPU_DISCARD(exit.rodata)                    \
  305.     MEM_DISCARD(exit.data)                        \
  306.     MEM_DISCARD(exit.rodata)
  307.  
  308. #define EXIT_TEXT                            \
  309.     *(.exit.text)                            \
  310.     DEV_DISCARD(exit.text)                        \
  311.     CPU_DISCARD(exit.text)                        \
  312.     MEM_DISCARD(exit.text)
  313.  
  314.         /* DWARF debug sections.
  315.         Symbols in the DWARF debugging sections are relative to
  316.         the beginning of the section so we begin them at 0.  */
  317. #define DWARF_DEBUG                            \
  318.         /* DWARF 1 */                        \
  319.         .debug          0 : { *(.debug) }            \
  320.         .line           0 : { *(.line) }            \
  321.         /* GNU DWARF 1 extensions */                \
  322.         .debug_srcinfo  0 : { *(.debug_srcinfo) }        \
  323.         .debug_sfnames  0 : { *(.debug_sfnames) }        \
  324.         /* DWARF 1.1 and DWARF 2 */                \
  325.         .debug_aranges  0 : { *(.debug_aranges) }        \
  326.         .debug_pubnames 0 : { *(.debug_pubnames) }        \
  327.         /* DWARF 2 */                        \
  328.         .debug_info     0 : { *(.debug_info            \
  329.                 .gnu.linkonce.wi.*) }            \
  330.         .debug_abbrev   0 : { *(.debug_abbrev) }        \
  331.         .debug_line     0 : { *(.debug_line) }            \
  332.         .debug_frame    0 : { *(.debug_frame) }            \
  333.         .debug_str      0 : { *(.debug_str) }            \
  334.         .debug_loc      0 : { *(.debug_loc) }            \
  335.         .debug_macinfo  0 : { *(.debug_macinfo) }        \
  336.         /* SGI/MIPS DWARF 2 extensions */            \
  337.         .debug_weaknames 0 : { *(.debug_weaknames) }        \
  338.         .debug_funcnames 0 : { *(.debug_funcnames) }        \
  339.         .debug_typenames 0 : { *(.debug_typenames) }        \
  340.         .debug_varnames  0 : { *(.debug_varnames) }        \
  341.  
  342.         /* Stabs debugging sections.  */
  343. #define STABS_DEBUG                            \
  344.         .stab 0 : { *(.stab) }                    \
  345.         .stabstr 0 : { *(.stabstr) }                \
  346.         .stab.excl 0 : { *(.stab.excl) }            \
  347.         .stab.exclstr 0 : { *(.stab.exclstr) }            \
  348.         .stab.index 0 : { *(.stab.index) }            \
  349.         .stab.indexstr 0 : { *(.stab.indexstr) }        \
  350.         .comment 0 : { *(.comment) }
  351.  
  352. #ifdef CONFIG_GENERIC_BUG
  353. #define BUG_TABLE                            \
  354.     . = ALIGN(8);                            \
  355.     __bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) {        \
  356.         VMLINUX_SYMBOL(__start___bug_table) = .;        \
  357.         *(__bug_table)                        \
  358.         VMLINUX_SYMBOL(__stop___bug_table) = .;            \
  359.     }
  360. #else
  361. #define BUG_TABLE
  362. #endif
  363.  
  364. #ifdef CONFIG_PM_TRACE
  365. #define TRACEDATA                            \
  366.     . = ALIGN(4);                            \
  367.     .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {        \
  368.         VMLINUX_SYMBOL(__tracedata_start) = .;            \
  369.         *(.tracedata)                        \
  370.         VMLINUX_SYMBOL(__tracedata_end) = .;            \
  371.     }
  372. #else
  373. #define TRACEDATA
  374. #endif
  375.  
  376. #define NOTES                                \
  377.     .notes : AT(ADDR(.notes) - LOAD_OFFSET) {            \
  378.         VMLINUX_SYMBOL(__start_notes) = .;            \
  379.         *(.note.*)                        \
  380.         VMLINUX_SYMBOL(__stop_notes) = .;            \
  381.     }
  382.  
  383. #define INITCALLS                            \
  384.     *(.initcallearly.init)                        \
  385.     VMLINUX_SYMBOL(__early_initcall_end) = .;            \
  386.       *(.initcall0.init)                        \
  387.       *(.initcall0s.init)                        \
  388.       *(.initcall1.init)                        \
  389.       *(.initcall1s.init)                        \
  390.       *(.initcall2.init)                        \
  391.       *(.initcall2s.init)                        \
  392.       *(.initcall3.init)                        \
  393.       *(.initcall3s.init)                        \
  394.       *(.initcall4.init)                        \
  395.       *(.initcall4s.init)                        \
  396.       *(.initcall5.init)                        \
  397.       *(.initcall5s.init)                        \
  398.     *(.initcallrootfs.init)                        \
  399.       *(.initcall6.init)                        \
  400.       *(.initcall6s.init)                        \
  401.       *(.initcall7.init)                        \
  402.       *(.initcall7s.init)
  403.  
  404. #define PERCPU(align)                            \
  405.     . = ALIGN(align);                        \
  406.     VMLINUX_SYMBOL(__per_cpu_start) = .;                \
  407.     .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {        \
  408.         *(.data.percpu.page_aligned)                \
  409.         *(.data.percpu)                        \
  410.         *(.data.percpu.shared_aligned)                \
  411.     }                                \
  412.     VMLINUX_SYMBOL(__per_cpu_end) = .;
  413.